{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 决策树"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**工作原理**：得到一个原始数据集，然后基于最好的属性值划分数据集，由于特征值可能多于两个，因此可能存在大于两个分支的数据集划分。  \n",
    "              第一次划分之后，数据将被向下传递到树分支的下一个节点，在这个节点上，我们可以再次划分数据。如此反复，直至程序遍历  \n",
    "              完所有划分数据集的属性或者每个分支下的所有实例都具有相同的分类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算给定数据集的香农熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log\n",
    "def calcShannonEnt(dataSet):\n",
    "    numEntries = len(dataSet)\n",
    "    labelCounts = {}\n",
    "    for featVec in dataSet:\n",
    "        currentLabel = featVec[-1]\n",
    "        if currentLabel not in labelCounts.keys():\n",
    "            labelCounts[currentLabel] = 0\n",
    "        labelCounts[currentLabel] +=1\n",
    "    shannonEnt = 0.0\n",
    "    for key in labelCounts:\n",
    "        prob = float(labelCounts[key])/numEntries\n",
    "        shannonEnt -= prob*log(prob,2)\n",
    "    return shannonEnt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createDataSet():\n",
    "    dataSet = [[1,1,'yes'],\n",
    "              [1,1,'yes'],\n",
    "              [1,0,'no'],\n",
    "              [0,1,'no'],\n",
    "              [0,1,'no']]\n",
    "    labels = ['no surfacing','flippers']\n",
    "    return dataSet, labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 按照给定的特征划分数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitDataSet(dataSet, axis, value):\n",
    "    retDataSet = []\n",
    "    for featVec in dataSet:\n",
    "        if featVec[axis] == value:\n",
    "            reducedFeatVec = featVec[:axis]   #去掉axis特征\n",
    "            reducedFeatVec.extend(featVec[axis+1:]) #将符合条件的添加到返回的数据集\n",
    "            retDataSet.append(reducedFeatVec)  \n",
    "    return retDataSet   #返回划分后的数据集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 根据信息增益最大原则，选择最好的数据集划分方式\n",
    "特征$A$对训练集$D$的信息增益$g(D,A)$，定义为集合$D$的经验熵$H(D)$与特征$A$给定条件下$D$的经验条件熵$H(D|A)$之差，即  \n",
    "               $$g(D,A) = H(D) - H(D|A)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "设训练数据集为$D$，$|D|$表示其样本容量，即样本个数。设有$K$个类$C_k$，$k=1,2,…,K$，$|C_k|$为属于类$C_k$的样本个数，$\\sum_{k=1}^K|C_k|=|D|$。\n",
    "设特征$A$有$n$个不同的取值${a_1,a_2,…,a_n}$，根据特征$A$的取值将$D$划分为$n$个子集$D_1,D_2,…,D_n$，$|D_i|$为$D_i$的样本个数，$\\sum_{i=1}^n|D_i|=|D|$。  \n",
    "记子集$D_i$中属于类$C_k$的样本的集合为$D_ik$，即$D_{ik}=D_i\\bigcap C_k$，$|D_{ik}|$为$D_{ik}$的样本个数，于是信息增益的算法如下：  \n",
    "输入：训练数据集$D$和特征$A$；  \n",
    "输出：特征$A$对训练数据集$D$的信息增益$g(D,A)$。  \n",
    "（1）计算数据集$D$的经验熵$H(D)$   \n",
    "$$H(D) = -\\sum_{k=1}^K\\frac{|C_k|}{|D|}log_2\\frac{|C_k|}{|D|}$$\n",
    "（2）计算特征$A$对数据集$D$的经验条件熵$H(D|A)$\n",
    "$$H(D|A) = \\sum_{i=1}^n\\frac{|D_i|}{|D|}H(D_i)=-\\sum_{i=1}^n\\frac{|D_i|}{|D|}\\sum_{k=1}^K\\frac{|D_{ik}|}{|D_i|}log_2\\frac{|D_{ik}|}{|D_i|}$$\n",
    "（3）计算信息增益\n",
    "$$g(D,A) = H(D) - H(D|A)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chooseBestFeatureToSplit(dataSet):\n",
    "    numFeatures = len(dataSet[0]) - 1  \n",
    "    baseEntropy = calcShannonEnt(dataSet) #计算整个数据集的原始香农熵\n",
    "    bestInfoGain = 0.0  #信息增益\n",
    "    bestFeature = -1   #最优特征的索引值\n",
    "    for i in range(numFeatures):\n",
    "        #获取dataSet的第i个特征\n",
    "        featList = [example[i] for example in dataSet]\n",
    "        uniqueVals = set(featList)   #创建set集合，元素不可重复\n",
    "        newEntropy = 0.0    #经验条件熵\n",
    "        for value in uniqueVals:    #计算信息增益\n",
    "            subDataSet = splitDataSet(dataSet, i, value)  #subDataSet划分后的子集\n",
    "            prob = len(subDataSet)/float(len(dataSet))   #计算子集的概率\n",
    "            newEntropy += prob*calcShannonEnt(subDataSet)  #根据公式计算经验条件熵\n",
    "        infoGain = baseEntropy - newEntropy   #计算信息增益\n",
    "        if(infoGain > bestInfoGain):    \n",
    "            bestInfoGain = infoGain    #更新信息增益，找到最大的信息增益\n",
    "            bestFeature = i    #记录最大信息增益的特征索引值\n",
    "    return bestFeature   #返回信息增益最大的特征的索引值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 用多数表决的方法决定该叶子节点的分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "def majorityCnt(classList):\n",
    "    classCount = {}\n",
    "    for vote in classList:    #统计classList中每个元素出现的个数\n",
    "        if vote not in classCount.keys():\n",
    "            classCount[vote] = 0\n",
    "        classCount[vote] += 1\n",
    "    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1), reverse=True)\n",
    "    return sortedClassCount[0][0]   #返回classList中出现次数最多的元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建树的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createTree(dataSet, labels):\n",
    "    classList = [example[-1] for example in dataSet]   #取分类标签\n",
    "    if classList.count(classList[0]) == len(classList):  #如果类别完全相同则停止继续划分\n",
    "        return classList[0]\n",
    "    if len(dataSet[0]) == 1:    #遍历完所有特征时返回出现次数最多的类标签\n",
    "        return majorityCnt(classList)\n",
    "    bestFeat = chooseBestFeatureToSplit(dataSet)  #选择最优特征\n",
    "    bestFeatLabel = labels[bestFeat]   #最优特征的标签\n",
    "    myTree = {bestFeatLabel:{}}    #根据最优特征的标签生成树\n",
    "    del(labels[bestFeat])    #删除已经使用特征标签\n",
    "    featValues =[example[bestFeat] for example in dataSet]    #得到训练集中所有最优特征的属性值\n",
    "    uniqueVals = set(featValues)   #去掉重复的属性值\n",
    "    for value in uniqueVals:   #遍历特征，创建决策树。\n",
    "        subLabels = labels[:]\n",
    "        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)\n",
    "    return myTree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 获取叶节点的数目和树的层数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getNumLeafs(myTree):\n",
    "    numLeafs = 0\n",
    "    #firstStr = myTree.keys()[0]\n",
    "    #python3中myTree.keys()返回的是dict_keys,不再是list,所以不能使用myTree.keys()[0]的方法获取结点属性，可以使用list(myTree.keys())[0]\n",
    "    firstStr = next(iter(myTree))                                \n",
    "    secondDict = myTree[firstStr]\n",
    "    for key in secondDict.keys():\n",
    "        if type(secondDict[key]).__name__=='dict':\n",
    "            numLeafs += getNumLeafs(secondDict[key])\n",
    "        else: numLeafs += 1\n",
    "    return numLeafs\n",
    "\n",
    "def getTreeDepth(myTree):\n",
    "    maxDepth = 0\n",
    "    firstStr = next(iter(myTree))   \n",
    "    secondDict = myTree[firstStr]\n",
    "    for key in secondDict.keys():\n",
    "        if type(secondDict[key]).__name__=='dict':\n",
    "            thisDepth = 1+getTreeDepth(secondDict[key])\n",
    "        else: thisDepth = 1\n",
    "        if thisDepth > maxDepth: maxDepth = thisDepth\n",
    "    return maxDepth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用文本注解绘制树节点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "decisionNode = dict(boxstyle=\"sawtooth\", fc='0.8')  #设置节点格式\n",
    "leafNode = dict(boxstyle=\"round4\", fc='0.8')   #设置叶节点格式\n",
    "arrow_args = dict(arrowstyle=\"<-\")   #定义箭头格式\n",
    "\n",
    "def plotNode(nodeTxt, centerPt, parentPt, nodeType):\n",
    "    createPlot.ax1.annotate(nodeTxt, xy=parentPt,xycoords='axes fraction',\n",
    "                            xytext=centerPt, textcoords='axes fraction',va='center',\n",
    "                            ha='center',bbox=nodeType,arrowprops=arrow_args)   #绘制节点\n",
    "\n",
    "def plotMidText(cntrPt, parentPt, txtString):    #计算标注位置\n",
    "    xMid = (parentPt[0]-cntrPt[0])/2.0 + cntrPt[0]\n",
    "    yMid = (parentPt[1]-cntrPt[1])/2.0 + cntrPt[1]\n",
    "    createPlot.ax1.text(xMid,yMid, txtString)\n",
    "\n",
    "def plotTree(myTree, parentPt, nodeTxt):\n",
    "    numLeafs = getNumLeafs(myTree)   #获取决策树叶结点数目，决定了树的宽度\n",
    "    depth = getTreeDepth(myTree)  #获取决策树层数\n",
    "    firstStr = next(iter(myTree)) \n",
    "    cntrPt = (plotTree.xOff +(1.0 + float(numLeafs))/2.0/plotTree.totalW,plotTree.yOff) #中心位置\n",
    "    plotMidText(cntrPt, parentPt, nodeTxt) #标注有向边属性值\n",
    "    plotNode(firstStr, cntrPt, parentPt, decisionNode) #绘制结点\n",
    "    secondDict = myTree[firstStr]  #下一个字典，也就是继续绘制子结点\n",
    "    plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD #y偏移\n",
    "    for key in secondDict.keys():\n",
    "        if type(secondDict[key]).__name__=='dict':  #测试该结点是否为字典，如果不是字典，代表此结点为叶子结点\n",
    "            plotTree(secondDict[key],cntrPt,str(key))  #不是叶结点，递归调用继续绘制\n",
    "        else:  #如果是叶结点，绘制叶结点，并标注有向边属性值 \n",
    "            plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW\n",
    "            plotNode(secondDict[key],(plotTree.xOff,plotTree.yOff),cntrPt, leafNode)\n",
    "            plotMidText((plotTree.xOff,plotTree.yOff),cntrPt, str(key))\n",
    "    plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD\n",
    "    \n",
    "def createPlot(inTree):\n",
    "    fig = plt.figure(1,facecolor='white')  #创建fig\n",
    "    fig.clf()  #清空fig\n",
    "    axprops = dict(xticks=[], yticks=[])\n",
    "    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)  #去掉x、y轴\n",
    "    plotTree.totalW = float(getNumLeafs(inTree))  #获取决策树叶结点数目\n",
    "    plotTree.totalD = float(getTreeDepth(inTree))  #获取决策树层数\n",
    "    plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0  #x偏移\n",
    "    plotTree(inTree,(0.5,1.0),'')    #绘制决策树\n",
    "    plt.show() #显示绘制结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用决策树的分类函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classify(inputTree, featLabels, testVec):\n",
    "    firstStr = inputTree.keys()[0]\n",
    "    secondDict = inputTree[firstStr]\n",
    "    featIndex = featLabels.index(firstStr)\n",
    "    for key in secondDict.keys():\n",
    "        if testVec[featIndex] == key:\n",
    "            if type(secondDict[key]).__name__=='dict':\n",
    "                classLabel = classify(secondDict[key],featLabels,testVec)\n",
    "            else:   classLabel = secondDict[key]\n",
    "    return classLabel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用pickle模块存储决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "def storeTree(inputTree, filename):\n",
    "    import pickle\n",
    "    fw = open(filename,'w')\n",
    "    pickle.dump(inputTree,fw)\n",
    "    fw.close()\n",
    "\n",
    "def grabTree(filename):\n",
    "    import pickle\n",
    "    fr = open(filename)\n",
    "    return pickle.load(fr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'tearRate': {'normal': {'astigmatic': {'no': {'age': {'pre': 'soft', 'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}}, 'young': 'soft'}}, 'yes': {'prescript': {'myope': 'hard', 'hyper': {'age': {'pre': 'no lenses', 'presbyopic': 'no lenses', 'young': 'hard'}}}}}}, 'reduced': 'no lenses'}}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fr=open('lenses.txt')\n",
    "lenses = [inst.strip().split('\\t') for inst in fr.readlines()]\n",
    "lensesLabels = ['age','prescript','astigmatic','tearRate']\n",
    "lensesTree = createTree(lenses,lensesLabels)\n",
    "print(lensesTree)\n",
    "createPlot(lensesTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
